Region based image compositing

ABSTRACT

A method of creating an image is disclosed. The image is formed by rendering and compositing at least a plurality of graphical objects whereby each of the objects has a predetermined outline. The method comprises the following steps. Firstly, dividing a space in which the outlines are defined into a plurality of regions whereby each of the regions is defined by at least one region outline. The region outline substantially follows at least one of the predetermined outlines or parts thereof and is substantially formed by segments of a virtual grid encompassing the space. Secondly, manipulating the regions to determine a plurality of further regions whereby each of the further regions has a corresponding compositing expression. Fourthly, classifying the further regions according to at least one attribute of the graphical objects within the further regions. Fifthly, modifying each of the corresponding compositing expressions according to a classification of each of the further regions to form an augmented compositing expression for each of the further regions. Finally, compositing the image using each of the augmented compositing expression.

FIELD OF THE INVENTION

The present invention relates to the creation of computer-generated images both in the form of still pictures and video imagery, and, in particular, relates to efficient process, apparatus, and system for creating an image made up by compositing multiple components.

BACKGROUND

Computer generated images are typically made up of many differing components or graphical elements which are rendered and composited together to create a final image. In recent times, an “opacity channel” (also known as a “matte”, an “alpha channel”, or simply “opacity”) has been commonly used. The opacity channel contains information regarding the transparent nature of each element. The opacity channel is stored alongside each instance of a colour, so that, for example, a pixel-based image with opacity stores an opacity value as part of the representation of each pixel. An element without explicit opacity channel information is typically understood to be fully opaque within some defined bounds of the element, and assumed to be completely transparent outside those bounds.

An expression tree offers a systematic means for representating an image in terms of its constituent elements and which facilitates later rendering. Expression trees typically comprise a plurality of nodes including leaf nodes, unary nodes and binary nodes. Nodes of higher degree, or of alternative definition may also be used. A leaf node, being the outer most node of an expression tree, has no descendent nodes and represents a primitive constituent of an image. Unary nodes represent an operation which modifies the pixel data coming out of the part of the tree below the unary operator. Unary nodes include such operations as colour conversions, convolutions (blurring etc) and operations such as red-eye removal. A binary node typically branches to left and right subtrees, wherein each subtree is itself an expression tree comprising at least one leaf node. Binary nodes represent an operation which combines the pixel data of its two children to form a single result. For example, a binary node may be one of the standard “compositing operators” such as OVER, IN, OUT, ATOP and alpha-XOR, examples of which and other are seen in FIG. 20.

Several of the above types of nodes may be combined to form a compositing tree. An example of this is shown in FIG. 1. The result of the left-hand side of the compositing tree may be interpreted as a colour converted image being clipped to spline boundaries. This construct is composited with a second image.

Although the non-transparent area of a graphical element may of itself be of a certain size, it need not be entirely visible in a final image, or only a portion of the element may have an effect on the final image. For example, assume an image of a certain size is to be displayed on a display. If the image is positioned so that only the top left corner of the image is displayed by the display device, the remainder of the image is not displayed. The final image as displayed on the display device thus comprises the visible portion of the image, and the invisible portion in such a case need not be rendered.

Another way in which only a portion of an element may have an effect is when the portion is obscured by another element. For example, a final image to be displayed (or rendered) may comprise one or more opaque graphical elements, some of which obscure other graphical elements. Hence, the obscured elements have no effect on the final image.

A conventional compositing model considers each node to be conceptually infinite in extent. Therefore, to construct the final image, a conventional system would apply a compositing equation at every pixel of the output image. Interactive frame rates of the order greater than 15 frames per second can be achieved by relatively brute-force approaches in most current systems, because the actual pixel operations are quite simple and can be highly optimised. This highly optimised code is fast enough to produce acceptable frame rates without requiring complex code. However, this is certainly not true in a compositing environment.

The per-pixel cost of compositing is quite high. This is because typically an image is rendered in 24-bit colour in addition to an 8-bit alpha channel, thus giving 32 bits per pixel. Each compositing operator has to deal with each of the four channels. Therefore, the approach of completely generating every pixel of every required frame when needed is inefficient, because the per-pixel cost is too high.

Problems arise with prior art methods when rendering graphical objects which include transparent and partially-transparent areas. Further, such methods typically do not handle the full range of compositing operators.

SUMMARY OF THE INVENTION

It is an object of the present invention to substantially overcome, or ameliorate, one or more of the deficiencies of the above mentioned methods by the provision of a method for creating an image made up by compositing multiple components.

According to one aspect of the present invention there is provided a method of creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said method comprising the steps of:

dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space;

manipulating said regions to determine a plurality of further regions, wherein each said further region has a corresponding compositing expression;

classifying said further regions according to at least one attribute of said graphical objects within said further regions;

modifying each said corresponding compositing expression according to a classification of each said further region to form an augmented compositing expression for each said further region; and

compositing said image using each of said augmented compositing expressions.

According to another aspect of the present invention there is provided a method of method of creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said method comprising the steps of:

dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space, wherein each object has two region outlines arranged either side of said predetermined outline to thus define three regions for each said object, and wherein each said region has a corresponding compositing expression;

classifying said regions according to at least one attribute of said graphical objects within said regions;

modifying each said corresponding compositing expression according to a classification of each said region to form an augmented compositing expression for each said region; and

compositing said image using each of said augmented compositing expressions.

According to still another aspect of the present invention there is provided an apparatus for creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said apparatus comprising:

dividing means for dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space;

manipulating means for manipulating said regions to determine a plurality of further regions, wherein each said further region has a corresponding compositing expression;

classifying means for classifying said further regions according to at least one attribute of said graphical objects within said further regions;

modifying means for modifying each said corresponding compositing expression according to a classification of each said further region to form an augmented compositing expression for each said further region; and

compositing means for compositing said image using each of said augmented compositing expressions.

According to still another aspect of the present invention there is provided an apparatus for creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said apparatus comprising:

dividing means for dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space, wherein each object has two region outlines arranged either side of said predetermined outline to thus define three regions for each said object, and wherein each said region has a corresponding compositing expression;

classifying means for classifying said regions according to at least one attribute of said graphical objects within said regions;

modifying means for modifying each said corresponding compositing expression according to a classification of each said region to form an augmented compositing expression for each said region; and

compositing means for compositing said image using each of said augmented compositing expressions.

According to still another aspect of the present invention there is provided a computer program product including a computer readable medium having a plurality of software modules for creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said computer program product comprising:

dividing module for dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space;

manipulating module for manipulating said regions to determine a plurality of further regions, wherein each said further region has a corresponding compositing expression;

classifying module for classifying said further regions according to at least one attribute of said graphical objects within said further regions;

modifying module for modifying each said corresponding compositing expression according to a classification of each said further region to form an augmented compositing expression for each said further region; and

compositing module for compositing said image using each of said augmented compositing expressions.

According to still another aspect of the present invention there is provided a computer program product including a computer readable medium having a plurality of software modules for creating an image, said image to be formed by rendering and compositing at least a plurality of graphical objects, each said object having a predetermined outline, said computer program product comprising:

dividing module for dividing a space in which said outlines are defined into a plurality regions, each said region being defined by at least one region outline substantially following at least one of said predetermined outlines or parts thereof and being substantially formed by segments of a virtual grid encompassing said space, wherein each object has two region outlines arranged either side of said predetermined outline to thus define three regions for each said object, and wherein each said region has a corresponding compositing expression;

classifying module for classifying said regions according to at least one attribute of said graphical objects within said regions;

modifying module for modifying each said corresponding compositing expression according to a classification of each said region to form an augmented compositing expression for each said region; and

compositing module for compositing said image using each of said augmented compositing expressions.

BRIEF DESCRIPTION OF THE DRAWINGS

A preferred embodiment of the present invention will now be described with reference to the following drawings:

FIG. 1 is an example of a compositing tree;

FIG. 2 illustrates an image containing a number of overlapping objects and the corresponding compositing tree;

FIG. 3 shows the image of FIG. 2 illustrating the different regions which exist in the image and listing the compositing expression which would be used to generate the pixel data for each region;

FIG. 4 is the image of FIG. 3, illustrating the compositing operations after being optimised according to one example of the preferred embodiment;

FIG. 5 illustrates the result of combining two region descriptions using the Union operation according to the preferred embodiment;

FIG. 6 illustrates the result of combining two region descriptions using the Intersection operation according to the preferred embodiment;

FIG. 7 illustrates the result of combining two region descriptions using the Difference operation according to the preferred embodiment;

FIGS. 8A to 8D illustrate the steps involved in combining two region groups using the Over operation according to the present invention;

FIG. 9 illustrates an image and compositing tree according to another example of the preferred embodiment;

FIG. 10 illustrates an image and compositing tree according to still another example of the preferred embodiment;

FIG. 11 illustrates the effect on the image of FIG. 10 of moving region A;

FIG. 12 illustrates an image and compositing tree according to still another example of the preferred embodiment;

FIG. 13 illustrates the effect on the image of FIG. 12 of moving region A;

FIG. 14 illustrates the effect on the image of FIG. 12 of moving region B; and

FIG. 15 illustrates those nodes in a compositing tree which need to have their region groups updated if leaf nodes B and H change;

FIG. 16 illustrates a region and its x and y co-ordinates;

FIG. 17 illustrates two regions and their x and y co-ordinates;

FIG. 18 illustrates an image and compositing tree according to still another example of the preferred embodiment;

FIG. 19 illustrates an apparatus upon which the preferred embodiment is implemented;

FIG. 20 depicts the result of a variety of compositing operators useful with the present invention;

FIG. 21 illustrates regions formed by combining two circles with non-grid-aligned regions;

FIG. 22 illustrates improved regions formed by combining two circles with grid-aligned regions;

FIG. 23 is a flowchart showing a method of creating an image in accordance with the preferred embodiment; and

Appendix 1 is a listing of source code according to the present invention

DETAILED DESCRIPTION

1.0 Underlying Principles

The basic shape of operands to compositing operators in most current systems is the rectangle, regardless of the actual shape of the object being composited. It is extremely easy to write an operator which composites within the intersection area of two bounding boxes. However, as a bounding box typically does not accurately represent the actual bounds of a graphical object, this method results in a lot of unnecessary compositing of completely transparent pixels over completely transparent pixels. Furthermore, when the typical make-up of a composition is examined, it can be noticed that areas of many of the objects are completely opaque. This opaqueness can be exploited during the compositing operation. However, these areas of complete opaqueness are usually non-rectangular and so are difficult to exploit using compositing arguments described by bounding boxes. If irregular regions are used for exploiting opaque objects when compositing, then these regions could then be combined in some way to determine where compositing should occur. Furthermore, if any such region is known to be fully transparent or fully opaque, further optimisations are possible.

Most current systems fail to exploit similarities in composition between one frame and the next. It is rare for everything to change from frame to frame and therefore large areas of a compositing tree will remain unchanged. An example of this is where a cartoon type character comprising multiple graphical objects is rendered on a display. If, for example, the character spilt some paint on its shirt in the next frame, then it is not necessary to render the entire image again. For example, the head and legs of the character may remain the same. It is only necessary to render those components of the image that have been altered by the action. In this instance, the part of the shirt on which the paint has been spilt may be re-rendered to be the same colour as the paint, whilst the remainder of the character stays the same. Exploiting this principle may provide large efficiency improvements. If incremental changes are made to the compositing tree, then only a reduced amount of updating is necessary to affect the change.

Many current graphical systems use what is known as an immediate mode application program interface (API). This means that for each frame to be rendered, the complete set of rendering commands is sent to the API. However, sending the complete set of rendering commands is somewhat inefficient in a compositing environment, as typically, large sections of the compositing tree will be unchanged from one frame to the next, but would be completely re-rendered anyway in immediate mode. The preferred embodiment, on the other hand, is considered by the present inventors to be best described as a retained mode API. Retained mode means that instead of providing the complete compositing tree on a per-frame basis, the user provides an initial compositing tree, and then modifies it on a per-frame basis to effect change. Changes which can be made to the tree include geometrically transforming part or all of the tree, modifying the tree structure (unlinking and linking subtrees), and modifying attributes (eg: color) of individual nodes. Note that such modifications may not necessarily mean that the tree structure, for example as seen in FIG. 1, will change where only the attributes of an individual node have been modified.

The rendering operation of the preferred embodiment is a combination of a number of techniques and assumptions which combine to provide high quality images and high frame rates. Some of the contributing principles are:

(i) The use of irregular regions to minimise per-pixel compositing. For example, if one graphical object is on top of another, then pixel compositing is only needed inside the area where the two objects intersect. Having the ability to use irregular regions gives the ability to narrow down areas of interest much more accurately.

(ii) An assumption is made that in the transition from one frame to the next, only part of the tree will change. This can be exploited by caching away expensive-to-generate information regarding the composition so that it can be re-used from one frame to the next. Examples of expensive-to-generate information are—regions of interest (boundaries of areas of intersection between objects etc); pixel data (representing expensive composites etc); and topological relationships between objects.

(iii) If an opaque object is composited with another object using the OVER operator, then the opaque object completely obscures what it is composited onto (inside the opaque objects area). This is a very useful property because it means that no expensive pixel compositing is required to achieve the output pixel within the area of overlap. (The pixel value is the same as that at the equivalent spot on the opaque object). Opaque objects induce similar behaviour in most of the compositing operators. Therefore, the preferred embodiment attempts to exploit opaque areas as much as possible.

FIG. 23 is a flowchart showing a method of creating an image in accordance with the preferred embodiment of the present invention. The image is formed by rendering graphical objects whereby each of the objects has a predetermined boundary outline. The process begins at step 2301, where a space in which the object outlines are defined is divided into a number of regions. Each of the regions is defined by at least one of the predetermined boundary outlines or parts thereof. The regions are formed by segments of a grid which encompasses the space in which the predetermined outlines are defined. At the next step 2303, the regions are manipulated to determine a number of further regions. Each of the further regions has a corresponding compositing expression. The process of dividing the space into a number of regions and manipulating those regions is described in detail particularly with reference to section 2.3 below. Section 2.3 includes two pseudocode listings which describe steps 2301 and 2303 for the “OVER” and “IN” compositing operations. The process continues at step 2305, where the further regions are classified according to attributes of the objects that fall within the further regions. At the next step 2307, each of the corresponding compositing expressions are modified according to a classification of each of the further regions. The modifications form an augmented compositing expression for each of the further regions. The process of classifying the further regions and modifying each of the corresponding compositing expressions is described in detail particularly with reference to section 2.4 below. Section 2.4 includes two pseudocode listings which describe steps 2305 and 2207 for the “OVER” and “IN” compositing operations. The process concludes at step 2309, where the image is composited using each of the augmented compositing expressions. Step 2309 is described in detail with reference to section 2.6, below, which includes a pseudocode listing demonstrating the compositing process.

2.0 Basic Static Rendering

Static Rendering deals with the problem of generating a single image from a compositing tree as quickly as possible. Some of the pixel compositing methods of the preferred embodiment will be explained using a static rendering example.

An example of a simple compositing tree which consists of leaf node objects and only using the “OVER” operator is shown in FIG. 2. Conventionally, each node is considered to be conceptually infinite in extent. One method to construct the final image is to apply the compositing equation (((D OVER B) OVER C) OVER (A OVER E)) at every pixel of the output image. However, this is quite an inefficient method.

A composition can generally be subdivided into a number of mutually exclusive irregular regions. The above compositing expression may be simplified independently within each region. In the example of FIG. 2, A, C and E represent opaque objects. B and D, on the other hand are partially transparent. FIG. 3 shows the different regions (1–10) produced using the five objects which exist in the example, and the compositing expression which would be used to generate the pixel data for each specific region.

The compositing expressions provided in FIG. 3 make no attempt to exploit the properties of the object's opacity. If these properties are used to simplify the compositing expressions for each region, the expressions of FIG. 4 are obtained resulting in a simplification of the rendering of regions 2, 3, 5, 6, 7, 8 and 9 compared with FIG. 3. These simplified compositing expressions would result in far fewer pixel compositing operations being performed to produce the final picture.

FIG. 4 represents the region subdivision for the root of the compositing tree. However, every node in the compositing tree can itself be considered the root of a complete compositing tree. Therefore, every node in the compositing tree can have associated with it a group of regions which together represent the region subdivision of the subtree of which the node is the root. Region subdivision provides a convenient means of managing the complexity of a compositing tree and an efficient framework for caching expensive data.

Using the principles noted above, a compositing expression can be simplified dependent upon whether the graphical objects being composited are wholly opaque, wholly transparent or otherwise (herewith deemed “ordinary”).

Table 1 shows how the compositing operations of FIG. 20 can be simplified when one or both operands are opaque or transparent.

TABLE 1 Expression A's opacity B's opacity Optimised AoverB Transparent Transparent neither Transparent Ordinary B Transparent Opaque B Ordinary Transparent A Ordinary Ordinary AoverB Ordinary Opaque AoverB Opaque Transparent A Opaque Ordinary A Opaque Opaque A AroverB Transparent Transparent neither Transparent Ordinary B Transparent Opaque B Ordinary Transparent A Ordinary Ordinary BoverA Ordinary Opaque B Opaque Transparent A Opaque Ordinary BoverA Opaque Opaque B AinB Transparent Transparent neither Transparent Ordinary neither Transparent Opaque neither Ordinary Transparent neither Ordinary Ordinary AinB Ordinary Opaque A Opaque Transparent neither Opaque Ordinary AinB Opaque Opaque A ArinB Transparent Transparent neither Transparent Ordinary neither Transparent Opaque neither Ordinary Transparent neither Ordinary Ordinary BinA Ordinary Opaque BinA Opaque Transparent neither Opaque Ordinary B Opaque Opaque B AoutB Transparent Transparent neither Transparent Ordinary neither Transparent Opaque neither Ordinary Transparent A Ordinary Ordinary AoutB Ordinary Opaque neither Opaque Transparent A Opaque Ordinary AoutB Opaque Opaque neither AroutB Transparent Transparent neither Transparent Ordinary B Transparent Opaque B Ordinary Transparent neither Ordinary Ordinary BoutA Ordinary Opaque BoutA Opaque Transparent neither Opaque Ordinary neither Opaque Opaque neither AatopB Transparent Transparent neither Transparent Ordinary B Transparent Opaque B Ordinary Transparent neither Ordinary Ordinary AatopB Ordinary Opaque AatopB Opaque Transparent neither Opaque Ordinary AatopB Opaque Opaque A AratopB Transparent Transparent neither Transparent Ordinary neither Transparent Opaque neither Ordinary Transparent A Ordinary Ordinary BatopA Ordinary Opaque BatopA Opaque Transparent A Opaque Ordinary BatopA Opaque Opaque B AxorB Transparent Transparent neither Transparent Ordinary B Transparent Opaque B Ordinary Transparent A Ordinary Ordinary AxorB Ordinary Opaque AxorB Opaque Transparent A Opaque Ordinary AxorB Opaque Opaque neither 2.1 Basic Data Model

Associated with every node in a compositing tree is a group of mutually exclusive regions which together represent the non-transparent area of the node. It should be noted that the region descriptions that the preferred embodiment uses are generally not pixel accurate. A region may in fact contain some transparent pixels. However, any point lying outside of all the regions at a node is certain to be transparent. The set of the mutually exclusive regions at a node is known as a region group. A leaf node region group may contain only one or two regions. The region group at the root of the tree may contain hundreds of regions. Each region in a region group contains the following basic data:

(i) A Region Description is a low-level representation of the boundaries of the region. The region descriptions of all the regions in a region group must be mutually exclusive (non-intersecting). However, the preferred embodiment is not limited to using axis-parallel (ie: every side parallel or perpendicular to a scan line of an output device) region descriptions. The preferred embodiment allows region descriptions which more closely represent arbitrary shaped regions.

(ii) A Proxy is some means of caching the pixel data resulting from applying the operations specified by the compositing expression at every pixel inside the region description. A proxy can be as simple as a 24-bit colour bitmap, or something much more complicated (such as a run-length encoded description). Fundamentally, a proxy simply has to represent pixel data in some way which makes it efficient to retrieve and use.

Every region group also contains a region description which is the union of all the region descriptions of the regions in the region group. The region description essentially represents the entire coverage of the region group.

2.2 Region Descriptions and Region Arithmetic

The region arithmetic and data structure of the preferred embodiment has the following properties:

-   -   to allow the representation of complex regions, including convex         regions, concave regions and regions with holes. This is         necessary so that a region will be reasonably able to follow the         geometry of the graphic object it represents;     -   is space efficient. In a complicated composition there will be         many regions. For memory efficiency, it is therefore preferable         that the cost of storing these regions is reasonably small;     -   the region arithmetic should support basic set operations—Union,         Intersection and Difference;     -   the above-noted basic operations should be efficient in terms of         speed. In a complex compositing tree, it is possible that a         large amount of region arithmetic will be undertaken. A poor         implementation of region arithmetic could lead to the time taken         by region arithmetic being greater than the time saved from the         reduction in per-pixel compositing;     -   it is advantageious if the region description can be         geometrically translated efficiently. In cases where a graphic         object is translated, the graphics objects associated regions         can then be translated quickly; and     -   it is sometimes helpful to be able to quickly compare two         regions to determine if they are the same. It is not necessary         to obtain any other statistics on their similarity, simple         equality is all that is required.         Two conventional region description techniques were considered         and rejected for the preferred embodiment. These were     -   Polygons: A polygon can be used to represent almost any object,         the disadvantage of using a polygon, however, is that a         ploygon's generality makes implementing the set operations slow         and inefficient.     -   Quadtrees: Using quadtrees, set operations are easy to implement         and are quite efficient. In addition, they can represent a wide         variety of regions given sufficient granularity (all edges in a         quadtree have to be axis-parallel). Their major failing is that         all quadtrees must be aligned on the same grid (granularity).         This means that it is impossible to simply translate a quadtree         by an arbitrary amount. Unless that amount is a multiple of the         underlying grid size, the quadtree will need to be recalculated         from the object it describes (otherwise it will keep growing).         Therefore, quadtrees are not suitable in application domains         where geometric translation is a frequent operation.

The region description data structure of the preferred embodiment can be understood by imagining that along a vertical line every coordinate has a state which is one of either inside or outside the region. The data structure stores those y co-ordinates at which some change of state between inside and outside occurs. For each such y co-ordinate, the data contains spans of coordinates each of which toggles the state of every vertical line running through the data. Each span of x co-ordinates is called a run. The sequence of runs associated with a y co-ordinate is called a row. For example, the region of FIG. 16 could be described by the following: row y=10: x=10,x=100 row y=100: x=10, x=100 Similarly, the regions of FIG. 17 could be described by the following: row y=10: x=10, x=100 row y=30: x=30, x=70 row y=70: x=30, x=70 row y=100: x+10, x=100 The data representing a region is represented by an array of integer values. There are two “special” values

R_(—)NEXT_(—)IS_(—)Y A beginning-of-row marker. Indicates that the next integer in the sequence will represent a y coordinate. R_(—)EOR Stands for End-of-Region. Indicates that the region description has finished.

All other values represent x or y coordinates. The x coordinates in a row represent runs. The first two co-ordinates represent a run, then the next two represent the next run and so on. Therefore, the x coordinates in a row should always be increasing. Also, there should always be an even number of x-coordinates in a row. The region data stream for FIG. 17 is shown below. R_(—)NEXT_(—)IS_(—)Y 10 10 100 R_(—)NEXT_(—)IS_(—)Y 30 30 70 R_(—)NEXT_(—)IS_(—)Y 70 30 70 R_(—)NEXT_(—)IS_(—)Y 100 10 100 R_(—)EOR

The preferred embodiment also contains the bounding box of the region, as this is useful in certain set operations.

As seen in FIG. 6, if two region descriptions are combined using a Union operation, then the resultant region description will describe an area in which either region description is active.

As seen in FIG. 7, if two region descriptions are combined using the Intersection operation, then the resultant region description will describe an area in which both the region descriptions are active.

If two region descriptions are combined using the Difference operation, then the resultant region will describe an area in which only the first region is active, as seen in FIG. 8.

2.3 Constructing Region Groups:

2.3.1 Constructing Leaf Node Region Groups

A region group for a leaf node will typically contain one or more regions, which together fully contain the non-transparent area of the graphical object represented by the leaf node. Typically, the non-transparent area is divided into regions where each region has some property that facilitates optimization. For example, the non-transparent area of some graphical object can be divided into two regions, one fully opaque and the other with ordinary opacity. The above mentioned compositing optimizations would apply where the opaque region is composited.

Alternatively, the leaf node could be subdivided based on some other attribute. For example, a leaf node could be divided into two regions, one representing an area of constant colour, the other representing blended colour. Areas of constant colour may be composited more efficiently than areas with more general colour description.

2.3.1.1 Region Formation and Phasing

When creating regions, it is not always beneficial that region boundaries follow graphical object boundaries precisely. What is important is that any property that facilitates optimization is valid at all points within a region said to have that property. For example, an opaque circle could be covered exactly by one circular region which is classified as opaque, or by two approximate regions, one fully opaque octagonal region inscribed in the circle, and one annular octagonal region of ordinary opacity that includes the remainder of the circle plus some area exterior to the circle.

There is typically a trade-off between how closely region boundaries follow graphical object boundaries and the benefits obtained. If region boundaries follow object boundaries very closely, a lot of work is usually involved in creating the region boundaries and in performing intersections and differences of regions (the reasons for needing to perform such operations are explained in later sections). However, if region boundaries are too approximate, they may either include large areas that are outside the objects' boundaries, resulting in too much unnecessary compositing, or they may fail to include large areas where known properties lead to optimization.

One approach, as illustrated in the appendix, is to limit region boundaries to sequences of horizontal and vertical segments. Using this approach, the typical segment size is chosen so that there is neither too much detail so that the region operations are overburdened, nor too much approximation to result in wasted compositing or insufficient optimization.

One method to improve the efficiency of region operations is to choose as many as is practical of the horizontal and vertical segments of substantially all region boundaries to be in phase. In other words, the horizontal and vertical segments are to be chosen from the horizontal and vertical lines of the same grid. The grid need not be regularly spaced, nor have the same spacing horizontally and vertically, although typically it will.

Choosing the horizontal and vertical segments from the horizontal and vertical lines of the same grid improves the efficiency of region operations by seeking to keep all region boundary detail to the level of detail contained in the underlying grid. Without constraining the majority of region boundary segments to a grid, region operators such as difference and intersection tend to produce a lot more fine detail. For example, in FIG. 21, two circles 901 and 902 are shown with respective regions 903 and 904 that are not grid-aligned. These circles are overlapped yielding difference regions 905 and 907, and intersection region 906. In FIG. 22, the same circles 901 and 902 have regions 913 and 914 that are aligned to grid 910. These circles are overlapped yielding difference regions 915 and 917 and intersection region 916. It can be seen in this example that the grid-aligned regions yield less detailed results at the expense of slightly less efficient region coverage. Regions 905, 906 and 907 together contain a total of sixty segments, while regions 915, 916 and 917 together contain only fifty-two.

2.3.2 Creating Binary Region Groups

The region groups of binary nodes in the compositing tree on the other hand are the result of combining the region groups of their child nodes. It will now be explained how region groups are combined to form new region groups. In this section, for simplicity only “OVER” and “IN” binary nodes will be dealt with. The operations required for binary nodes representing other compositing operators can easily be inferred from combining the “OVER” and “IN” cases in various ways.

For the sake of clarity, the method of the preferred embodiment is initially described without reference to optimization based properties such as opacity.

The following notation will be beneficial when considering binary region group creation:

Notation RG1 The region group of the binary node's left child RG2 The region group of the binary node's right child RG The region group of the binary node. It is this region group that is being initialised RG1→urgn The region description representing the union of all RG1's region descriptions (RG1's coverage region). RG2→urgn The region description representing the union of all RG2's region descriptions (RG2's coverage region). RG→urgn The union of all RG's region descriptions (to be initialised) (RG's coverage region) rg1i The current region in RG1 rg2j The current region in RG2 rg1i→rgn rg1i's region description rg2j→rgn rg2j's region description rg1i→proxy rg1i's proxy rg2j→proxy rg2j's proxy 2.3.2.1 Constructing “OVER” Region Groups

When constructing “OVER” region groups, only areas where the contributing region groups intersect need to be composited. Areas where one operand does not overlap the other involve no compositing. The method is broken into three iterative steps. First, the coverage region of the region group of the binary node that is being initialised (RG→urgn) is made equal to the union of the coverage regions of the binary nodes left child (RG1→urgn) and the binary node's right child (RG2→urgn). Then, for each region rg_(i) in RG1, the difference (diff_(—)rgn) between that region and RG2's coverage region (RG2→urgn) is then calculated. If the difference (diff_(—)rgn) is non-empty then a new region with diff_(—)rgn as its region description is added to RG. The proxy of this new difference region can be the same as the proxy rg1 _(i). No compositing is required to generate it. The difference regions between RG2's regions and RG1's coverage region are similarly constructed and added to RG. Finally, the intersection (inter_(—)rgn) between each region rg1 _(i) in RG1 and each region rg2 _(j) in RG2 is calculated. If the result of this intersection is non-empty, then a new proxy (new_(—)p) is created by compositing rg1 _(i)'s proxy with rg2 _(j)'s proxy using the over operation with the inter_(—)rgn. A new region is then added to RG with inter_(—)rgn as its region description and new_(—)p as its proxy. The method of constructing “OVER” groups in accordance with the preferred embodiment is described below using pseudo-code.

RG→urgn = RG1→urgn union RG2→urgn FOR i = 0 TO number of regions in RG1 DO diff_(—)rgn = rg1_(i)→rgn difference RG2→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region description and rg1_(i)→proxy as its proxy. (*) END IF FOR j = 0 TO number of regions in RG2 DO inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN create new proxy new_(—)p initialised to OVER of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. ADD to RG a new region with inter_(—)rgn as its region description and new_(—)p as its proxy. (+) END IF END DO END DO FOR j = 0 TO number of regions in RG2 DO diff_(—)rgn = rg2_(j)→rgn difference RG1→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region description and rg2_(j)→proxy as its proxy. (*) END IF END DO

The regions added by the ADD operations marked with asterisks (*) above are termed difference regions since their shape is the result of a difference operation. Such regions are very cheap computationally because their proxies require no compositing. The only work involved is the administrative overhead of adding a new region to the region group and the cost of the difference operation itself. In accordance with the preferred embodiment, a proxy is inherited from the region (in one of the child region groups) on which it is based. It can be seen that proxies which originate low in the compositing tree can be propagated upwards towards the root with minimal overhead (both in terms of speed and memory) by the use of difference regions.

The regions added by the ADD operation marked with the plus (+) are termed intersection regions. This is because their shape is the result of an intersection operation. The proxies of such regions are more expensive to generate than difference regions because they involve per-pixel compositing operations to be done within the area defined by the intersection. The more fidelity granted the region descriptions, the greater the saving in pixel processing costs, at the cost of a greater administrative overhead (more complex regions require longer to intersect etc).

FIGS. 8A to 8D provide a simple example of combining “OVER” region groups using the above method. The region group resulting from the combination contains 5 regions, 3 difference regions and 2 are intersection regions. FIG. 8A represents two region groups RG1 and RG2 which are to be combined. RG1 contains two regions 81 and 82, whereas RG2 only contains a single region 83. As seen in FIG. 8B, for each region in RG1, RG2's region coverage is subtracted from it. If the resultant region is non-empty, the resultant region becomes a region in the new region group. In this example both regions 81 and 83 produce non-empty difference regions 84 and 85 respectively. For each region in RG2, RG1's region coverage is subtracted from it, as seen in FIG. 8C. In this example difference region 86 is produced. Finally, every region in RG1 is intersected with every region in RG2, as seen in FIG. 8D. Any non-empty region becomes a region in the new region group. In this example, regions 81 and 83 produce 87. Further, regions 82 and 83 produce 88.

2.3.2.2 Constructing “IN” Region Groups

The properties of the “IN” operator lead to the fact that an “IN” binary region group only produces pixel data in the region of intersection between the two contributing region groups. Essentially, when compared to the algorithm used for “OVER” region groups, only intersection regions are generated. Therefore, for each region rg1 _(i) of RG1, and for each region rg2 _(j) of RG2 the intersection (inter_(—)rgn_(ij)) between rg1 _(i) and rg2 _(j) is calculated. If the intersection is non-empty then a new proxy (new_(—)p) is created by compositing rg1 _(i)'s proxy with rg2 _(j)'s proxy using the “in” operation within inter_(—)rgn_(ij). A new region is then added to RG with inter_(—)rgn as its region description and new_(—)p as its proxy. The pseudocode describing the method of constructing “IN” region groups in accordance to the preferred embodiment is provided below:

RG→urgn = RG1→urgn intersection RG2→urgn FOR i = 0 TO number of regions in RG1 DO FOR j = 0 TO number of regions in RG2 DO inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN create new proxy new_(—)p initialised to IN of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. ADD to RG a new region with inter_(—)rgn as its region description and new_(—)p as its proxy.(+) END IF END DO END DO

The major difference between the “IN” and the “OVER” cases is that the “OVER” case generates difference regions while “IN” does not. In the example demonstrated by FIGS. 8A to 8D, only new regions 97 and 98 would be generated, as these are intersection regions. Difference regions 94, 95 and 96 would not be generated using “IN”.

Using Table 2 below and the pseudocode examples of “OVER” and “IN”, the relevant code for other compositing operators can be derived.

2.3.2.3 Constructing Region Groups of Other Compositing Operators

Other compositing operators typically generate the same intersection regions as the “OVER” and “IN” cases do. However, they typically differ from one another (as indeed from “OVER” and “IN”) in what difference regions they generate. This is dependent on the particular properties of each compositing operator. Table 2 summarises which difference regions are generated for some commonly used compositing operators.

TABLE 2 Compositing Generate Diff Rgns from Generate Diff Rgns from Operator RG1? RG2? Over Yes Yes In No No Out Yes No Atop No Yes Xor Yes Yes Plus Yes Yes 2.4 Optimising using Opaque Areas

The preferred embodiment stores within each region a flag indicating whether the pixel data in the region proxy is completely opaque. It is therefore possible to reduce the number of per-pixel compositing operations by exploiting the effect opaque operands have on the compositing operators.

2.4.1 Opaque Area Optimisation for “Over” Region Groups

If an opaque region is “OVER” another region, then there is no need to compute the result of the composite, as no part of the right operand region's proxy is visible through the left operand's opaque proxy. In the preferred embodiment, the resultant region is made to reference the right operand's proxy, which has the same effect as actually doing the composite.

The method for opaque area optimisation for “OVER” region groups is a slightly modified version of the “OVER” region group construction method provided previously. The only difference is that when calculating the intersection region of the current region in RG1 and each region of RG2, a check is carried out to see whether the current region in RG1 is opaque. If this is the case, then the proxy of the newly calculated region (new_(—)p) will be the proxy of the current region in RG1.

The method is illustrated using the following pseudocode:

RG→urgn = RG1→urgn union RG2→urgn FOR i = 0 TO number of regions in RG1 DO diff_(—)rgn = rg1_(i)→rgn difference RG2→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region description and rg1_(i)→proxy as its proxy. (*) END IF FOR j = 0 TO number of regions in RG2 DO inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN IF rg1_(i) is OPAQUE THEN new_(—)p = rg1_(i)→proxy ELSE create new proxy new_(—)p initialised to OVER of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. END IF ADD to RG a new region with inter_(—)rgn as its region description and new_(—)p as its proxy. (+) END IF END DO END DO FOR j = 0 TO number of regions in RG2 DO diff_(—)rgn = rg2_(j)→rgn difference RG1→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region description and rg2_(j)→proxy as its proxy. (*) END IF END DO 2.4.2 Opaque Area Optimisation for “IN” Region Groups

If a region is “IN” an opaque region, then according to the properties of the “IN” operator, the resultant pixel data is the same as that of the left operand. This can be achieved by having the resultant region simply reference the proxy of the left operand. The method of the preferred embodiment is a slightly modified version of the “IN” region group construction method provided previously. The only difference is that when calculating the intersection region of the current region in RG1 and each region of RG2, a check is carried out to see whether the current region in RG2 is opaque. If this is the case, then the proxy of the newly calculated region (new_(—)p) will be the proxy of the current region in RG1.

The technique is illustrated using the following pseudocode:

RG→urgn = RG1→urgn intersection RG2→urgn FOR i = 0 TO number of regions in RG1 DO FOR j = 0 TO number of regions in RG2 DO inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN IF rg2_(j) is OPAQUE THEN new_(—)p = rg1_(i)→proxy ELSE create new proxy new_(—)p initialised to IN of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. END IF ADD to RG a new region with inter_(—)rgn as its region description and new_(—)p as its proxy. (+) END IF END DO END DO 2.5 Initialising the Entire Tree

The entire compositing tree can be initialised by using the above-described method of the preferred embodiment on every binary region group in the tree. A node cannot be initialised until its children have been initialised. Therefore the process simply starts at the bottom of the tree and works its way up towards the root. The process first checks to see if the current node is a leaf node. If this is the case, then a leaf node region group is constructed. However, in the case that the current node is a binary node then a binary node region group is constructed using the method of the preferred embodiment outlined in sections 2.4.1 and 2.4.2. The following pseudocode outlines a method for initialising all the region groups of the tree. The method utilises a recursive function, which is called passing the root of the tree as an argument.

tree_(—)init(node : tree ptr) BEGIN IF node is a leaf node THEN CONSTRUCT leaf node region group ELSE tree_(—)init(node→left) tree_(—)init(node→right) CONSTRUCT binary node region group by combining region groups of the left and right children END IF END tree_(—)init 2.6 Constructing the Resultant Image

Once the compositing tree has been initialised, the region group at the root of the tree contains a group of zero or more regions which together represent the partitioning of the resultant image into areas which differ in the way the image data was generated. Some of the regions' proxies can refer to image data directly from leaf nodes of the tree, having not required any compositing. Other regions, on the other hand, may have proxies which are the result of compositing operations. If a single resultant image is required, such as an image stored in a pixel buffer, this can be achieved by copying the image data from each region's proxy to the pixel buffer within the area corresponding to the region. The process is demonstrated in the pseudocode provided below, which is generalised and able to restrict the construction of the final image to any nominated update region.

construct_(‘3)image ( output_(—)image : pixel data ptr, urgn : region description ) BEGIN FOR i = 0 TO number of region in RG DO int_(—)rgn = rg_(i)→rgn intersection urgn IF int_(—)rgn is non-empty THEN COPY image data from rg_(i)→proxy to output_(—)image inside int_(—)rgn END IF END DO END construct_(—)image 3.0 Dynamic Rendering

Dynamic Rendering refers to the problem of generating multiple successive images. Given a compositing tree, it is possible to generate it's region groups (containing regions and proxies) using the method described above. A further embodiment of the above mentioned preferred method, which supports dynamic rendering is described below. The compositing tree represents an image. Changes to the tree can be made to make the tree represent a new image. The tree's region groups (and tree region description and proxies) are updated to reflect this modified tree. Performance is improved by exploiting commonality between the two images. An example will illustrate the techniques and terminology of the further embodiment.

FIG. 3 shows the region subdivision and the respective compositing expressions (advantage is not taken of opacity) for the simple compositing tree. Consider therefore the situation in which object A moves by a small amount relative to the other objects. Some regions in the region group at the root of the tree will be affected by A moving.

If opaque case optimisations are ignored, the regions with compositing expressions which include A will be significantly affected by A moving. The region numbers which are so affected are 2, 3, 5 and 6. When updating the region group at the root of the tree, those regions will need both their region descriptions and their proxies completely recalculated. This situation is known in the further embodiment as primary damage. Any region whose compositing equation includes an object which has changed in some way, may be said to suffer primary damage.

Regions that abut regions which have A in their compositing expression are also effected by A moving, though not as severely as those regions with primary damage. In the example, these other affected regions are 1, 4, 7 and 8. When updating the region group at the root of the tree, these regions will need their region descriptions recalculated. However, their proxies will only need to be recalculated in areas of the new region which were not included in the corresponding earlier region. This situation is known in the further embodiment as secondary damage. Generally, secondary damage is incurred if an object upon which a region's boundary (but not content) depends, changes in some way.

In order to reduce the per-frame update cost, it is important to reduce, as far as is practicable, the amount of work necessary, both in terms of per-pixel operations, but also in terms of region group operations. The concepts of primary and secondary damage are a way of facilitating this. If the preferred embodiment is able to accurately determine the minimum set of regions throughout all the compositing tree which have some kind of damage, then obviously the amount of work being done is reduced. The following sections describe how the reduction in work done is achieved.

3.1 Basic Data Model

The data model used for static rendering, consisting as it does of a region description and a proxy, is insufficient for use in dynamic rendering. This is because, for primary and secondary damage to be determined, it must be possible to associate regions of the same content between frames. To support the association of regions of the same content, some extra information is required in each region in a region group. Therefore, each region in a region group now contains the following data:

(i) A Region Description: A low-level representation of the boundaries of the region. The region descriptions of all the regions in a region group must be mutually exclusive (non-intersecting, non-overlapping).

(ii) A Proxy: Some means of caching the pixel data resulting from applying the operation specified by the compositing expression at every pixel inside the region description. A proxy can be as simple as a 24-bit colour bit-map, or something much more complicated (such as a run-length encoded description). Fundamentally, a proxy simply has to represent pixel data in some way which makes it efficient to retrieve and use.

iii) A Contents Label: A contents label represents a unique symbolic expression that describes the method of construction of image data. The terms in the symbolic expression distinguish between different categorisations of a source of image data. Therefore, the region groups of two distinct leaf nodes in the compositing tree will contain regions which are labelled with distinct contents labels even if their actual image data is equivalent. The further embodiment uses a system of unique integers to represent - - - contents labels. For example “23” could represent “(A over B) over C”.

(iv) A Flag Register: A general-purpose flag register used to store state during the region group update process. The exact flags stored here will be outlined in a later section.

3.2 Contents Labels

Leaf node region groups can contain multiple regions, with each region naturally having a unique contents label. For example, the region group of a leaf node in a compositing tree could contain a single region (tagged with a single contents label) representing the non-transparent area of the leaf node. Alternatively, the leaf node region group could contain two regions (each tagged with a different contents label), one representing the area of the leaf node which is completely opaque, the other representing the remaining non-transparent area. A leaf node can also be categorised even further, into an arbitrary number of regions (and associated contents labels).

One way a contents label can be created is by assigning a new one to a region of a leaf node region group. Another way is taking other contents labels and combining them to create a new contents label that represents the symbolic expression that represents the combination of the contributing expressions. For example, if the contents label representing ((A comp B) comp C) is combined with the contents label representing (D comp E) then a new contents label will be created which represents (((A comp B) comp C) comp (D comp E)).

As well as contents labels, dependency information is also required. Dependency information indicates how a given contents label is related to other contents labels, both in terms of how the contents of one region contribute to contents of other regions, and how change of a region boundary affect the boundary of other regions. The further embodiment associates the following data with each contents label.

(i) Primary Dependency List: Each primary dependency is a contents label L′ to which a contents label L directly contributes. In other words, a “primary dependency” is a contents label L′ representing an expression which has been constructed by combining L and some other contents label. Each time contents labels are combined, the contents label for the combination is added to the primary dependencies of all contributors.

(ii) Secondary Dependency List: Each secondary dependency is a contents label L″ which can be indirectly affected if the image represented by the contents label L has changed in some way that affects it's boundary. Whenever contents labels are combined, a contributing contents label is added to the secondary steps of the continuation if and only if the compositing operator yields a difference region with said contributing contents label. Table 2 shows which of some commonly used operators yield difference regions for their left and right operands. In addition, for a combination of (A comp B), the secondary dependencies of the combination contents labels for all (A comp b_(i)) and all (a_(j) comp B) are added, where a_(j) are the secondary dependencies of A and b_(i) are the secondary dependencies of B.

(iii) Property Information: Each contents label can represent contents which have properties which the compositing engine may be able to exploit. An example is that of opaqueness. If a contents label represents opaque content, then compositing that content could be much faster, as for certain operators, no per-pixel compositing operations would be required.

3.3 Contents Label Implementation

The further embodiment uses unique integers as contents labels, and stores a number representing the number of contents labels which currently exist. When a new contents label is created, the number is incremented and becomes the unique integer representing the contents label. This technique of assigning a contents label by monotonically incrementing an integer means that the contents labels' associated data structures can be stored in a one dimensional array which grows as more contents labels are added. A content label's data structure can be referenced simply by using the contents label as an index. When a leaf node contents label is created, the contents label is initialised to have no primary or secondary dependencies. If the current leaf node contents label is opaque, then a flag is set in content label i's properties.

The pseudocode below illustrates the basic techniques used to create a new contents label which is not dependent on other contents labels (ie: a leaf node region group contents label):

Notation opaque A flag passed to the function which indicates whether or not the contents label represents opaque content or not. cur_(—)clab A global integer which stores the last contents label created. clabs A global array which stores the associated data structures of the contents label. clabs[i]−>pri_(—)deps A pointer to the head of content label i's primary dependency list. clabs[i]−>sec_(—)deps A pointer to the head of content label i's secondary dependency list. clabs[i]−>properties A flag register representing contents label i's properties. create_(—)new_(—)contents_(—)label ( opaque : boolean ) : RETURNS unsigned int BEGIN INCREMENT cur_(—)clab. clabs[cur_(—)clab]−+prideps = NULL. clabs[cur_(—)clab]→sec_(—)deps = NULL. IF opaque THEN clabs[cur_(—)clab]→properties = OPAQUE. ELSE clabs[cur_(—)clab]→properties = 0. END IF RETURN cur_(—)clab. END create_(—)new_(—)contents_(—)label.

Contents labels can also be created to represent the combination of existing contents labels. This is achieved in the further embodiment by a hash table which maps an operation and the contents labels of its operands (hashed together to create a key) to a single contents label representing the result.

When a region is created which represents an intersection between two other regions (each with its own contents label), a new contents label is generated which is used to tag the new region. When this new contents label is generated, it must be added to the primary dependency lists of both its contributing operands. A secondary dependency list which depends on the secondary dependencies of the two contributing contents labels as well as the properties of the compositing operator must also be generated.

The process is recursive and begins by adding the newly created contents label (new_(—)c1) to the primary dependency lists of the contributing contents labels. Then, depending on the properties of the compositing operator, none, either or both of the contributing contents labels are added to the secondary dependency list. Then every contents label representing (clab1 op sd2 _(i)) and (sd1 _(i) op tab2) are added to the secondary dependency list.

Notation clab1 The first contributing contents label. clab2 The second contributing contents label. sd1i The i'th element of clab1's secondary dependency list. sd2i The i'th element of clab2's secondary dependency list. create_(—)binary_(—)contents_(—)label (

-   -   clab1: contents label,     -   clab2: contents label,     -   op: compositing operator         )         BEGIN

IF the hash table already contains an entry representing clab1 op clab2

THEN

-   -   RETURN the existing contents label representing the combination.

END IF

Generate a new entry in the hash table representing clab1 op clab2, mapping to new_(—)cl.

(Add the new contents label to the primary dependency lists of the contributing contents labels if the compositing op requires it)

add_(—)to_(—)primary_(—)dep_(—)list(clab1, new_(—)cl)

add_(—)to_(—)primary_(—)dep_(—)list(clab2, new_(—)cl)

(Generate the secondary dependencies)

IF op generates left diff rgns THEN

-   -   add clab1 to secondary deps

ENDIF

IF op generates right diff rgns THEN

-   -   add clab2 to secondary deps

END IF

FOR i=0 TO number of elements in sd1 DO

-   -   add_(—)to_(—)secondary_(—)dep_(—)list     -   (         -   new_(—)c1,         -   create_(—)binary_(—)contents_(—)label(sd1 _(i), clab2)

END DO

-   -   )

FOR i=0 TO number of elements in sd2 DO

-   -   add_(—)to_(—)secondary_(—)dep_(—)list     -   (         -   new_(—)c1,         -   create_(—)binary_(—)contents_(—)label(clab1, sd2 _(j))     -   )

END DO

END constuct_(—)binary_(—)contents_(—)label

3.4 Combining Region Groups for Dynamic Rendering

Before any incremental updates can be made to a compositing tree, the compositing tree must be constructed to be in a consistent initial state. The basic technique for achieving this is the same as that used for static rendering, except that support for contents labels is included.

Leaf node region groups are initialised essentially as with the static rendering case, except that each region in each leaf node region group is tagged with a unique contents label. Each contents label can in turn be tagged with various categorisation properties which may help the renderer to be more efficient. For example, a contents label can be tagged as being completely opaque.

The initialisation of binary nodes is also similar to the static rendering case. By way of example, the way in which the region group for an “OVER” binary node is constructed will now be explained. The techniques for constructing the region groups of the other compositing operators can easily be inferred from the “OVER” case.

When a difference region between rg_(i) of one operand and the coverage region of the other operand is calculated, the difference region inherits the contents label rg_(i). When an intersection region is created, on the other hand, a new contents label is created by combining the contents labels of the two contributing regions since the two contributing regions had their proxies composited into a new proxy which means new content. The pseudocode for constructing an “OVER” region group which includes contents label management is provided below:

Notation RG1 The region group of the binary node's left child RG2 The region group of the binary node's right child RG The region group of the binary node. It is this region group that we are initialising RG1→urgn The region description representing the union of all RG1's region descriptions (RG1's coverage region). RG1→urgn The region description representing the union of all RG2's region descriptions (RG2's coverage region). RG→urgn The union of all RG's region descriptions. rg1i The current region in RG1 rg2j The current region in RG2 rgli→rgn rg1i's region description rg2j→rgn rg2j's region description rgli→proxy rg1i's proxy rg2j→proxy rg2j's proxy RG→urgn = RG1→urgn union RG2→urgn FOR i = 0 TO number of regions in RG1 DO diff_(—)rgn = rg1_(i)→rgn difference RG2→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region descrip- tion, rg1_(i)→proxy as its proxy and rg1_(i)→clab as its contents label. END IF FOR j = 0 TO number of regions in RG2 DO inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN new_(—)clab = GENERATE a new unique contents label as a result of combining rg1_(i)→clab and rg2_(j)→clab. IF rg1_(i)→clab is OPAQUE THEN new_(—)p = rg1_(i)→proxy ELSE create new proxy new_(—)p initialised to OVER of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. END IF ADD to RG a new region with inter_(—)rgn as its region description, new_(—)p as its proxy and new_(—)clab as its contents label. END IF END DO END DO FOR j = 0 TO number of regions in RG2 DO diff_(—)rgn = rg2_(j)→rgn difference RG1→urgn IF diff_(—)rgn is non-empty THEN ADD to RG a new region with diff_(—)rgn as its region descrip- tion, rg2_(j)→proxy as its proxy and rg2_(j)→clab as its contents label. END IF END DO 3.5 Secondary Dependencies and Over

The rationale behind the preferred method used for generating secondary dependencies requires more explanation. Secondary dependencies are only generated when a new contents label is created by combining two other contents labels. As can be seen in the above pseudocode, this only occurs when an intersection region is generated. Essentially, the further embodiment uses contents labels generated for intersection regions as triggers—the regions tagged with two contents labels cannot indirectly affect one another unless they intersect. The secondary dependency list for a particular contents label is dependent on the compositing operator the composite contents label represents, the two contributing contents labels and their secondary dependency lists.

The method of the further embodiment of generating a secondary dependency list for a new contents label (C) which represents one contents label (A) composited over another contents label (B) using the “OVER” operator will now be explained. Elements of A's and B's secondary dependency lists are referred to as A_(i) and B_(i) respectively. First, both A and B are added to C's secondary dependency list. This is because if the region tagged with C changes its boundary, then it is likely that any regions tagged with A and B will need to be recalculated (because their regions are likely to abut C's region). Next, for each element of B's secondary dependency list, each contents labels representing (A OVER B_(i)) is added. A mapping representing A OVER B_(i) may not currently exist in the system and needs to be created. A secondary dependency list can contain contents labels which are not represented by any region in a region group. They could come into existance by changes in region boundaries. The rationale is that A intersects B, and therefore it is likely that A also intersects regions tagged with contents labels which exist in B's secondary dependency list. Similarly, for each element of A's secondary dependency list, each contents label representing (A_(i) OVER B) is added.

3.6 Contents Labels and Damage

The concepts of primary and secondary damage were introduced with reference to FIG. 3 to demonstrate that it is not always necessary to regenerate an entire image as a result of a change to the compositing tree. By keeping track of dependencies between regions of different content, it only becomes necessary to regenerate image data in regions whose contents have become damaged. The following explanation outlines the dependencies and damage for simple compositing tree changes. “Simple” means that only leaf nodes are modified. More complex change scenarios such as tree structure changes etc will be outlined in later sections.

If a leaf node is modified, the contents labels of its affected regions are said to be “primary damaged”. Primary-damaging a contents label involves recursively primary-damaging all its primary dependencies. Whenever a contents label is primary-damaged, all its secondary dependencies are non-recursively marked with secondary damage. The process begins by flagging the contents label to be damaged. The following pseudocode demonstrates how contents labels can be damaged:

Notation clab The contents label to be damaged pdi The i'th element of clab's primary dependency list. sdi The i'th element of clab's secondary dependency list. damage_(—)contents_(—)label (

clab: contents label,

)

BEGIN

FLAG dab with PRIMARY damage

FOR i=0 TO number of elements in sd DO

-   -   FLAG sd_(i) with SECONDARY damage

END DO

FOR i=0 TO number of elements in pd DO

-   -   damage_(—)contents_(—)label(pd_(i))

END DO

END damage_(—)contents_(—)label

When a tree update occurs, any region with its contents label marked as having primary damage will need to recalculate both its region boundaries and its proxy. Any region with its contents label marked as having secondary damage will need to recalculate its region description but will only need to recalculate its proxy in areas of the new region that were not included in the earlier region.

3.7 Examples of Contents Labels and Dependencies

In order to clarify the concepts of contents labels and damage, some examples of varying complexity will be presented.

3.7.1 Example 1

FIG. 9 will result in the following contents label table after the compositing tree is initially constructed (Note: in the following table contents labels are represented as unique strings not as integers where “over” has been abbreviated to “o”. This is simply for readability.):

Contents Label Primary Deps. Secondary Deps. A AoB B AoB AoB A, B

If A moves, then AoB will have primary damage, resulting in B having secondary damage.

3.7.2 Example 2

FIG. 10 will result in the following contents label table after the compositing tree is initially constructed:

Contents Label Primary Deps. Secondary Deps. A AoB, AoC B AoB, BoC AoB AoBoC A, B C AoC, BoC, (AoB)oC AoC A, C BoC B, C (AoB)oC AoB, C, AoC, BoC

In this example, every object intersects every other object, so if something changes, everything will be damaged in some way—everything which is a primary dependency of the changed object will have primary damage, whereas everything else will have secondary damage.

FIG. 11 illustrates the effect of A moving in a subsequent frame. As can be seen, if A is damaged, the regions defined by A, AoB, AoC and (AoB)oC will each have primary damage. The regions defined by B, C and BoC will each have secondary damage.

3.7.3 Example 3

FIG. 12 will result in the following contents label table after the compositing tree is initially constructed:

Contents Label Primary Deps. Secondary Deps. A AoB, AoC, AoE, Ao(DoE), AoD B AoB, BoC, BoE AoB AoBoE A, B D DoE, AoD, CoD, (AoC)oD E DoE, AoE, (AoB)oE, BoE, CoE, (BoC)oE, (AoC)oE DoE Ao(DoE), (AoC)o(DoE), D, E Co(DoE) C AoC, BoC, Co(DoE), CoE, CoD AoC AoCoE, (AoC)o(DoE), A, C (AoC)oD BoC (BoC)oE B, C AoE A, E (AoB)oE AoB, E, AoE, BoE BoE B, E CoE C, E (BoC)oE BoC, E, BoE, CoE AoD A, D CoD C, D (AoC)oE AoC, E, AoE, CoE Ao(DoE) A, DoE, AoD, AoE Co(DoE) C, DoE, CoD, CoE (AoC)o(DoE) AoC, DoE, Ao(DoE), Co(DoE), (AoC)oD, (AoC)oE (AoC)oD AoC, D, AoD, CoD

Since A intersects every other object, if A moves, a large amount of the compositing tree will need to be recomputed. FIG. 13 shows that the only part left alone is the area corresponding to BoC and its dependent BoCoE. To summarise:

-   -   Primary Damage—A, AoB, AoC, AoE, Ao(DoE), (AOB)oE, (AoC)oE,         (AoC)o(DoE), AoD, (AoC)oD     -   Secondary Damage—B, C, E, DoE, BoE, CoE, DoE, CoDoE

On the other hand, if B moves, the amount of damage is less than if A moved. This is because B doesn't intersect D. DoE, Ao(DOE), (AoC)o(DoE), Co(DOE) and (AoC)oE (and their ancestors) are not damaged when B moves. This is shown in FIG. 14. The rest of the damage is summarised as:

-   -   Primary Damage—B, AoB, BoC, BoE, (AoB)oE, (BOC)oE     -   Secondary Damage—A, E, C, AoE, CoE

The examples presented so far are simple, but they are sufficient to demonstrate that the dependencies techniques presented so far will damage those contents labels which are affected when a particular contents label/s is(are) damaged. In a typical complex composite, it is rare for large numbers of objects to intersect a large number of other objects, meaning that large areas of the compositing tree should be untouched during updates using the above technique.

3.8 Example of Secondary Dependencies and Compositing Operators

Consider a modified version of Example 3 above. FIG. 18 will result in the following contents label table after the compositing tree is initially constructed. Note that AaB represents A ATOP B and AiB represents A IN B etc:

Contents Label Primary Deps Secondary Deps A AaB B AaB, BoC AaB B C BoC, Co(DiE) BoC B, C D DiE E DiE DiE Co(DiE) Co(DiE) C, DiE

As seen in FIG. 18, the ATOP operator clips A to B's bounds, meaning that intersections between A and any of C, D or E never occur. Similar things occur with the IN operator. This means that the objects in this scene are less tightly coupled. For example, if A is changed, then only B and AaB are immediately damaged. Similarly, if E is damaged, it is only possible for DiE to be damaged.

3.9 Updating Region Groups

The further embodiment uses the contents label and damage framework to reduce the amount of work that has to be done to make a binary region group consistent with its updated operands during an update. The further embodiment does this by only updating those regions in a region group whose contents labels have primary or secondary damage, adding any new region which comes into existence as a result of the changes made to the compositing tree, and deleting any region in the right group whose contact no longer exists.

Each different binary operator has a different updating function which deals with the specific requirement of that operator. The process of updating region groups is a two-pass process. The first pass updates any intersection regions that have been primary damaged and adds any new intersection regions generated due to the damage. Each region of one operand's region group is intersected with each region of the other operand's region group whenever one or both of their corresponding contents labels are primary damaged. If the intersection is non-empty, then the further embodiment determines if a contents label representing the combination exists. If the contents label doesn't exist, one is created and primary damaged. Note that primary damaging a contents label will mark all it's secondary dependencies with secondary damage.

If a region in the region group is currently tagged with the primary damage contents label, the regions boundary and proxy are updated. If no such region exists in this region group, then a new region keyed by this contents label is added to the region group. A new proxy is generated and assigned to this region along with the right description relating from the intersection operation.

A difference between each region group of one operand and the coverage region of the other operand is calculated whenever the regions contents label has primary or secondary damage. If the difference is non-empty and a region tagged with the contents label exists in the region group, then it's region description and proxy reference are updated. If such a region doesn't exist then a region keyed by the contents label is added to the region group. The added region is assigned as a coverage region of the difference result and references the proxy of current region.

Each region of one operand's region group is interacted with each region of the other operand's region group whenever the contents label representing their combination has secondary damage and no primary damage. If the intersection is non-empty, the region group is searched looking for a region keyed by the contents label. If such a region exists its region description is updated and it's proxy is updated as the difference between the new and old regions. If such a region doesn't exist, then a region keyed by the contents label is created. The created region description is assigned the result of the interaction operation and it's proxy generated.

Pseudocode which illustrates a simple algorithm for updating a binary “OVER” region group is provided below.

Notation RG1 The region group of the binary node's left child RG2 The region group of the binary node's right child RG The region group of the binary node. It is this region group that is being initialised. RG1→urgn The region description representing the union of all RG1's region descriptions (RG1's coverage region). RG1→urgn The region description representing the union of all RG2's region descriptions (RG2's coverage region). RG→urgn The union of all RG's region descriptions. rg1i The current region in RG1 rg2j The current region in RG2 rg1i→rgn rg1i's region description rg2j→rgn rg2j's region description rg1i→proxy rg1i's proxy rg2j→proxy rg2j's proxy rg1i→clab rg1i's contents label rg2j→clab rg2j's contents label RG→urgn = RG1→urgn union RG2→urgn (First Pass - this pass is used to deal with primary damage of intersection regions and any new intersection regions generated) FOR i = 0 TO number of regions in RG1 DO FOR j = 0 TO number of regions in RG2 DO IF rg1_(i)→clab has PRIMARY damage OR rg2_(j)→clab has PRIMARY DAMAGE THEN inter_(—)rgn = rg1_(i)→rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN comp_(—)clab = SEARCH for an existing contents label which represents (rg1_(i)→clab comp rg2_(j)→clab). IF a region tagged with comp_(—)clab already exits in RG THEN IF rg1_(i)→clab is OPAQUE THEN new_(—)p = rg1_(i)→proxy ELSE create new proxy new_(—)p initialised to OVER of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. END IF MODIFY the existing region to have inter_(—)rgn as its region description and new_(—)p as its proxy. ELSE new_(—)clab = create_(—)binary_(—)contents_(—)label (rg1_(i)→clab, rg2_(j)→clab). IF rg1_(i)→clab is OPAQUE THEN new_(—)p = rg1_(i)→proxy ELSE create new proxy new_(—)p initialised to OVER of rg1_(i)→proxy and rg2_(j)→proxy inside inter_(—)rgn. END IF damage_(—)contents_(—)label(new_(—)clab) ADD to RG a new region with inter_(—)rgn as its region description, new_(—)p as its proxy and new_(—)clab as its contents label. (+) END IF FLAG the region as being ‘RETAIN AFTER UPDATE’ END IF END IF END DO END DO (Second Pass - this pass is used to deal with primary and secondary dam- age of difference regions and secondary damage of intersection regions) FOR i = 0 TO number of regions in RG1 DO IF rg1_(i)→clab has PRIMARY or SECONDARY damage THEN diff_(—)rgn = rg1_(i)→rgn difference RG2→urgn IF diff_(—)rgn is non-empty THEN IF a region tagged with rg1_(i)→clab already exists in RG THEN MODIFY it to have diff_(—)rgn as its region description and rg1_(i)→proxy as its proxy. ELSE ADD to RG a new region with diff_(—)rgn as its region description, rg1_(i)→proxy as its proxy and rg1_(i)→clab as its contents label. (*) END IF FLAG the region as being ‘RETAIN AFTER UPDATE’ END IF END IF FOR j = 0 TO number of regions in RG2 DO comp_(—)clab = SEARCH for an existing contents label which represents (rg1_(i)→clab comp rg2_(j)→clab). IF comp_(—)clab exists AND comp_(—)clab has SECONDARY damage but NO PRIMARY damage THEN inter_(—)rgn = rg1_(i)rgn intersection rg2_(j)→rgn IF inter_(—)rgn is non-empty THEN GET a reference to the existing region tagged in this region group with comp_(—)clab which MUST exist in this region group IF rg1_(i)→clab is OPAQUE THEN existing regions proxy = rg1_(i)→proxy ELSE update_(—)rgn = inter_(—)rgn difference the region's previous region description. update existing regions proxy to include OVER of rg1_(i)→proxy and rg2_(j) → proxy inside update region. END IF MODIFY the existing region to have inter_(—)rgn as its region description and new_(—)p as its proxy. FLAG the region as being ‘RETAIN AFTER UPDATE’ END IF END IF END DO END DO FOR j= 0 TO number of regions in RG2 DO IF rg2_(j)→clab has PRIMARY or SECONDARY damage THEN diff_(—)rgn = rg2_(j)→rgn difference RG1→urgn IF diff_(—)rgn is non-empty THEN IF a region tagged with rg2_(j→clab already exists in RG THEN) MODIFY it to have diff_(—)rgn as its region description and rg2_(j)→proxy as its proxy. ELSE ADD to RG a new region with diff_(—)rgn as its region description, rg2_(j)→proxy as its proxy and rg2_(j)→clab as its contents label. (*) END IF FLAG the region as being ‘RETAIN AFTER UPDATE’ END IF END IF END DO DELETE all regions of RG which are not marked RETAIN AFTER UP- DATE but whose contents labels have damage, and CLEAR flag in retained regions. 4.0 Tree Modifications (Linking and Unlinking)

More complex changes to a compositing tree can be achieved by changing the tree's structure. Most typical tree structure changes can be made by using two low level operations, link and unlink.

The unlink operation is used to separate a child node from its parent. After the operation is completed, the child node has no parent (meaning the child node can be linked in somewhere else), and the parent has a link available (meaning that some other node can be linked there instead). Nodes in the compositing tree above the unlinked child contain content which is dependent on the unlinked child. Therefore, at the time of the next update, the contents label present in the unlinked child at the time of unlinking must be damaged to ensure that the dependent region groups higher in the tree are appropriately updated. The updating is achieved by the parent node caching away those contents label existing in its unlinked child. If another subtree is linked in its place and subsequently unlinked without the region group of the parent being updated, it is not necessary to cache the contents labels of this new subtree. Pseudocode for the unlink operation is provided below. Note that the UNLINKED_(—)LEFT or UNLINKED_(—)RIGHT flag is set so that the contents labels of a newly linked subtree may be damaged when region groups (including their proxies) higher in the tree must then be updated.

unlink ( node : compositing tree node ) BEGIN parent = node →parent. node →parent = NULL. IF node is parent's left child THEN parent →left = NULL. IF parent doesn't have UNLINKED_(—)LEFT set THEN SET the UNLINKED_(—)LEFT flag in parent. ELSE. RETURN. END IF ELSE IF node is parent's right child THEN parent →right = NULL. IF parent doesn't have UNLINKED_(—)RIGHT set THEN SET the UNLINKED_(—)RIGHT flat in parent. ELSE RETURN END IF END IF COPY all the contents labels in node's region group into an array stored in parent →unlinked_(—)clabs. END unlink

The link operation involves linking a node with no parent to a free link of a parent node. Pseudocode for the operation is provided below:

link ( child : compositing tree node, parent : compositing tree node, which_(—)link : either LEFT or RIGHT ) BEGIN child →parent = parent IF which_(‘3)link is LEFT THEN parent →left = child. ELSE parent →right = child. END IF END LINK 4.1 Updating the Entire Compositing Tree

If a leaf node in the compositing tree changes, the region group of every node in a direct line from the leaf node to the root of tree must be updated using the methods described above. FIG. 15 shows circled those nodes which need to have their region groups updated if leaf nodes B and H change in some way.

Pseudocode for the tree updating method is provided below:

update_(—)tree ( node : compositing tree node ) BEGIN IF node is leaf node THEN Rerender the leaf node and update its region group. ELSE IF unlinking occurred in left subtree or left subtree contains dirty leaf nodes THEN update_(—)tree(node →left). END IF. IF unlinking occurred in right subtree or right subtree contains dirty leaf nodes THEN update_(—)tree(node →right). END IF. IF node has UNLINKED_(—)LEFT or UNLINKED_(—)RIGHT flags set THEN CALL damage_(—)contents_(—)label on every element of node→unlinked_(—)clabs. IF node has UNLINKED_(—)LEFT set THEN CALL damage_(—)contents_(—)label on every contents label existing in node→left's region group. CLEAR the UNLINKED_(—)LEFT flag in node. END IF IF node has UNLINKED_(—)RIGHT set THEN CALL damage contents_(—)label on every contents label existing in node→right's region group. CLEAR the UNLINKED_(—)RIGHT flag in node. END IF END IF CALL the region group update routine appropriate for node's compositing operator. END IF END update_(—)tree

The embodiments of the invention can be implemented using a conventional general-purpose computer system 2100, such as that shown in FIG. 19, wherein the process described with reference to FIG. 1 to FIG. 18 are implemented as software recorded on a computer readable medium that can be loaded into and carried out by the computer. The computer system 2100 includes a computer module 2101, input devices 2102, 2103 and a display device 2104.

With reference to FIG. 19, the computer module 2101 includes at least one processor unit 2105, a memory unit 2106 which typically includes random access memory (RAM) and read only memory (ROM), input/output (I/O) interfaces including a video interface 2107, keyboard 2118 and mouse 2120 interface 2108 and an I/O interface 2110. The storage device 2109 can include one or more of the following devices: a floppy disk, a hard disk drive, a CD-ROM drive or similar a non-volatile storage device known to those skilled in the art. The components 2105 to 2110 of the computer module 2101, typically communicate via an interconnected bus 2114 and in a manner which results in a usual mode of operation of the computer system 2100 known to those in the relevant art. Examples of computer systems on which the embodiments can be practised include IBM-PC/ATs and compatibles, Sun Sparcstations or alike computer system. In particular, the pseudocode described herein can be programmed into any appropriate language and stored for example on the HDD and executed in the RAM 2106 under control of the processor 2105 with the results being stored in RAM within the video interface 2107 and reproduced on the display 2116. The programs may be supplied to the system 2100 on a pre-programmed floppy disk or CD-ROM or accessed via a connection with a computer network, such as the Internet.

The aforementioned preferred method(s) comprise a particular control flow. There are many other variants of the preferred method(s) which use different control flows without departing the spirit or scope of the invention. Furthermore one or more of the steps of the preferred method(s) may be performed in parallel rather sequential.

The foregoing describes only several embodimens of the present invention, and modifications, obvious to those skilled in the art, can be made thereto without departing from the scope of the present invention.

In the context of this specification, the word “comprising” means “including principally but not necessarily solely” or “having” or “including” and not “consisting only of”. Variations of the word comprising, such as “comprise” and “comprises” have corresponding meanings. 

1. A method of generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each representing one of the objects or an operation for combining objects or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said method comprising the steps of: for at least one object node, forming one or more mutually exclusive regions, each of the mutually exclusive regions being defined by a region outline substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, the virtual grid comprising a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; for at least one operation node, forming a plurality of further mutually exclusive regions, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one further attribute; and for at least one of the further mutually exclusive regions, determining pixel data from the further attributes associated with the at least one further mutually exclusive region in order to generate the image.
 2. A method according to claim 1, wherein the one or more attributes is any one or more of color, opacity and object outline.
 3. A method according to claim 1, wherein said step of forming a plurality of further mutually exclusive regions includes applying set operations to the mutually exclusive regions.
 4. A method according to claim 3, wherein the set operations include difference and/or intersection operations.
 5. A method according claim 1, wherein the virtual grid is regularly spaced.
 6. A method according to claim 1, wherein the virtual grid is irregularly spaced.
 7. A method according to claim 1, further comprising a step of storing a flag to indicate whether data of an object is opaque or ordinary.
 8. A method according to claim 7, further comprising a step of optimizing the compositing expression based on a value of the flag for contributing objects.
 9. A method according to claim 1, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the determination of pixel data in said determining step for the corresponding one or more of the further mutually exclusive regions.
 10. A method according to claim 1, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data in said determining step for a corresponding one or more of the further mutually exclusive regions.
 11. A method of generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each representing one of the objects or an operation for combining objects or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said method comprising the steps of: for at least one object node forming one or more mutually exclusive regions substantially within the object represented by the node, one of the regions being defined by at least two region outlines substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, two of the at least two region outlines for a particular object being arranged on either side of the predetermined outline for the particular object such that the object comprises at least two corresponding mutually exclusive regions, wherein the virtual grid comprises a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, and wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; for at least one operation node, forming a plurality of further mutually exclusive regions, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one further attribute; and for at least one of the further mutually exclusive regions, determining pixel data from the further attributes associated with the at least one further mutually exclusive region in order to generate the image.
 12. A method according to claim 11, wherein the one or more attributes includes any one of color, opacity or object outline.
 13. A method according to claim 11, wherein the virtual grid is regularly spaced.
 14. A method according to claim 11, wherein the virtual grid is irregularly spaced.
 15. A method according to claim 11, further comprising a step of storing a flag to indicate whether data of an object is opaque or ordinary.
 16. A method according to claim 15, further comprising the step of optimizing the compositing expression based on a value of the flag for contributing objects.
 17. A method according to claim 11, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the determination of pixel data in said determining step for the corresponding ones of the further mutually exclusive regions.
 18. A method according to claim 11, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data in said determining step for a corresponding one or more of the further mutually exclusive regions.
 19. An apparatus for generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each representing one of the objects or an operation for combining objects or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said apparatus comprising: mutually exclusive regions forming means for forming one or more mutually exclusive regions for at least one object node, each of the mutually exclusive regions being defined by a region outline substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, the virtual grid comprising a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; further region forming means for forming a plurality of further mutually exclusive regions for at least one operation node, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one further attribute; and generating means for determining pixel data from the further attributes associated with at least one further mutually exclusive region in order to generate the image.
 20. An apparatus according to claim 19, wherein the one or more attributes is any one or more of color, opacity and object outline.
 21. An apparatus according to claim 19, wherein said further region forming means applies set operations to the mutually exclusive regions.
 22. An apparatus according to claim 21, wherein the set operations include difference and/or intersection operations.
 23. An apparatus according to claim 19, wherein the virtual grid is regularly spaced.
 24. An apparatus according to claim 19, wherein the virtual grid is irregularly spaced.
 25. An apparatus according to claim 19, further comprising means for storing a flag to indicate whether data of an object is opaque or ordinary.
 26. An apparatus according to claim 25, further comprising means for optimizing the compositing expression based on a value of the flag for contributing objects.
 27. An apparatus according to claim 19, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the determination of pixel data by said generating means for the corresponding ones of the further mutually exclusive regions.
 28. An apparatus according to claim 19, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data by said generating means for a corresponding one or more of said further mutually exclusive regions.
 29. An apparatus for generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each representing one of the objects or an operation for combining objects or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said apparatus comprising: mutually exclusive forming means for forming one or more mutually exclusive regions substantially within an object represented by at least one object node, one of the regions being defined by at least two region outlines substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, two of the at least two region outlines for a particular object being arranged on either side of the predetermined outline for the particular object such that the object comprises at least two corresponding mutually exclusive regions, wherein the virtual grid comprises a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, and wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; further region forming means for forming a plurality of further mutually exclusive regions for at least one operation node, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of the one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one further attribute; and generation means for determining pixel data from the further attributes associated with at least one of the further mutually exclusive regions in order to generate the image.
 30. An apparatus according to claim 28, wherein the one or more attributes comprises any one or more of color, opacity and object outline.
 31. An apparatus according to claim 29, wherein the virtual grid is regularly spaced.
 32. An apparatus according to claim 29, wherein the virtual grid is irregularly spaced.
 33. An apparatus according to claim 29, further comprising means for storing a flag to indicate whether data of an object is opaque or ordinary.
 34. An apparatus according to claim 33, further comprising means for optimizing the compositing expression based on a value of the flag for contributing objects.
 35. An apparatus according to claim 29, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the the determination of pixel data by said generating means for the corresponding ones of the further mutually exclusive regions.
 36. An apparatus according to claim 29, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data by said generating means for a corresponding one or more of the further mutually exclusive regions.
 37. A computer program product including a computer readable medium having a plurality of software modules for generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each representing one of the objects or an operation for combining objects or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said computer program product comprising: a mutually exclusive region forming module for forming one or more mutually exclusive regions, each of the mutually exclusive regions being defined by a region outline substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, the virtual grid comprising a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; a further region forming module for forming a plurality of further mutually exclusive regions for at least one operation node, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one further attribute; and a generating module for determining pixel data from the further attributes associated with at least one further mutually exclusive region in order to generate the image.
 38. A computer program product according to claim 37, wherein the one or more attributes is any one or more of color, opacity and object outline.
 39. A computer program product according to claim 37, wherein said further region forming module applies set operations to the mutually exclusive regions.
 40. A computer program product according to claim 39, wherein the set operations include difference and/or intersection operations.
 41. A computer program product according to claim 37, wherein the virtual grid is regularly spaced.
 42. A computer program product according to claim 37, wherein the virtual grid is irregularly spaced.
 43. A computer program product according to claim 37, further comprising a storing module for storing a flag to indicate whether data of an object is opaque or ordinary.
 44. A computer program product according to claim 43, further comprising a module for optimizing the compositing expression based on a value of the flag for contributing objects.
 45. A computer program product according to claim 37, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the determination of pixel data by said generating module for the corresponding ones of the further mutually exclusive regions.
 46. A computer program product according to claim 37, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data by said generating module for a corresponding one or more of the further mutually exclusive regions.
 47. A computer program product including a computer readable medium having a plurality of software modules for generating a pixel image, the image being formed by rendering and compositing a plurality of graphical objects according to an expression tree representing a compositing expression for the image, the expression tree comprising a plurality of nodes each node representing one of the objects or an operation for combining operations or results of other operations, each of the objects comprising a predetermined outline and one or more attributes associated therewith, said computer program product comprising: a mutually exclusive forming module for forming one or more mutually exclusive regions substantially within an object represented by at least one object node, one of the regions being defined by at least two region outlines substantially following at least part of the predetermined outline of the object, each of the region outlines being formed from horizontal and vertical segments of a virtual grid encompassing a space in which the predetermined outlines are defined, two of the at least two region outlines for a particular object being arranged on either side of the predetermined outline for the particular object such that the object comprises at least two corresponding mutually exclusive regions, wherein the virtual grid comprises a plurality of cells, each cell comprising a plurality of pixels both horizontally and vertically there within, and wherein each of the mutually exclusive regions has one or more attributes associated therewith depending on the attributes associated with the object; a further region forming module for forming a plurality of further mutually exclusive regions for at least one operation node, each of the further mutually exclusive regions being formed from the horizontal and vertical segments corresponding to the mutually exclusive regions of the one or more object nodes associated with the operation node, each of the further mutually exclusive regions having one or more further attributes associated therewith, wherein the value of at least one of the further attributes is dependent on the values of the attributes associated with a plurality of the mutually exclusive regions of the one or more object nodes, and wherein one or more of the attributes associated with the plurality of mutually exclusive regions is unused in determining the value of the at least one further attribute, thereby optimizing the determination of the at least one fruther attribute; and a generation module for determining pixel data from the further attributes associated with at least one of the further mutually exclusive regions in order to generate the image.
 48. A computer program product according to claim 47, wherein the one or more attributes comprises any one or more of color, opacity and object outline.
 49. A computer program product according to claim 47, wherein the virtual grid is regularly spaced.
 50. A computer program product according to claim 47, wherein the virtual grid is irregularly spaced.
 51. A computer program product according to claim 47, further comprising a storing module for storing a flag to indicate whether data of an object is opaque or ordinary.
 52. A computer program product according to claim 51, further comprising a module for optimizing the compositing expression based on a value of the flag for contributing objects.
 53. A computer program product according to claim 47, wherein a wholly opaque object in one of the mutually exclusive regions acts to eliminate one or more objects within a corresponding one or more of the further mutually exclusive regions from the determination of pixel data by said generation module for the corresponding ones of the further mutually exclusive regions.
 54. A computer program product according to claim 47, wherein a wholly transparent object in one of the mutually exclusive regions eliminates at least itself from the determination of pixel data by said generation module for a corresponding one or more of the further mutually exclusive regions. 